define(["jquery", "easy-admin"], function ($, ea) {

    var init = {
        table_elem: '#currentTable',
        table_render_id: 'currentTableRenderId',
        index_url: 'insurance.import/index',
        add_url: 'insurance.import/add',
        edit_url: 'insurance.import/edit',
        delete_url: 'insurance.import/delete',
        export_url: 'insurance.import/export',
        modify_url: 'insurance.import/modify',
        import_url: 'insurance.import/import',
        transfer_url: 'insurance.import/transfer',
    };

    var active = {
        table: null,
        load: function() {
            layui.upload.render({
                elem: '#upload-drag',
                url: '', // 实际使用时改成您自己的上传接口即可。
                accept: 'file',
                exts: 'xlsx|xls|csv', 
                size: 10 * 1024,
                auto: false,
                choose: function(obj) {
                    // 文件选择回调（关键：在此读取文件内容）
                    obj.preview(function(index, file, result){
                        if (!file) return;
            
                        // 校验文件格式（Layui 已通过 exts 限制，但二次确认更安全）
                        if (!file.name.endsWith('.xls')) {
                            layer.msg('请选择 .xls 格式文件！', {icon: 2});
                            return;
                        }
            
                        // 校验文件大小（10MB 以内）
                        if (file.size > 10 * 1024 * 1024) {
                            layer.msg('文件大小不能超过 10MB！', {icon: 2});
                            return;
                        }
            
                        // 使用 xlsx.js 读取并解析文件
                        // readAndParseXls(file);
                        active.readAndParseExcel(file, function(header, parsedData) {
                            // 解析成功后，渲染 Layui 表格
                            active.renderLayuiTable(header, parsedData);
                        });
                    })
                },
                done: function (res) {
                    layer.msg('上传成功');
                },
            });
        },
        // 读取并解析 XLS 文件的核心函数
        readAndParseExcel: function (file, callback) {
            const reader = new FileReader(); // 创建文件读取器

            // 读取完成后触发
            reader.onload = function(e) {
                try {
                    // 1. 读取文件二进制数据
                    const data = new Uint8Array(e.target.result);

                    // 2. 使用 xlsx.js 解析 XLS 文件
                    const workbook = XLSX.read(data, {type: 'array'}); // 读取工作簿

                    // 3. 获取第一个工作表（默认读取第一个 Sheet）
                    const sheetName = workbook.SheetNames[0]; // 工作表名称（如 "Sheet1"）
                    const worksheet = workbook.Sheets[sheetName]; // 工作表对象

                    // 4. 将工作表转换为 JSON 数据（两种常用格式）
                    // 格式 1：首行为标题，生成对象数组（{ 列名: 值 }）
                    const jsonData = XLSX.utils.sheet_to_json(worksheet, {header: 1});
 
                    jsonData.map((row, rowIndex) => {
                        if (rowIndex === 0) return row; // 标题行不处理
                        const excelTime1 = row[1]; // 假设第二列（索引 1）是 Excel 时间序列值
                        if (typeof excelTime1 === 'number') {
                            // 使用严格转换函数（修正 1900 年问题）
                            row[1] = active.excelTimeToDateStrict(excelTime1);
                            row[1] = active.formatDateToYyyyMmDd(row[1]);
                        }
                        const excelTime2 = row[2]; // 假设第二列（索引 1）是 Excel 时间序列值
                        if (typeof excelTime2 === 'number') {
                            // 使用严格转换函数（修正 1900 年问题）
                            row[2] = active.excelTimeToDateStrict(excelTime2);
                            row[2] = active.formatDateToYyyyMmDd(row[2]);
                        }
                        const excelTime3 = row[3]; // 假设第二列（索引 1）是 Excel 时间序列值
                        if (typeof excelTime3 === 'number') {
                            // 使用严格转换函数（修正 1900 年问题）
                            row[3] = active.excelTimeToDateStrict(excelTime3);
                            row[3] = active.formatDateToYyyyMmDd(row[3]);
                        }
                        return row;
                    });
                    const validData = [];
                    if (jsonData.length <= 0) {
                        return false;
                    }
                    const header = jsonData[0]; // 标题行
                    for (let i = 1; i < jsonData.length; i++) {
                        const row = jsonData[i].filter(cell => cell !== ''); // 过滤空单元格
                        if (row.length === header.length) { // 确保列数与标题一致
                            validData.push(row); // 转换为对象数组（需匹配列名）
                            // validData.push({ ...row }); // 转换为对象数组（需匹配列名）
                        }
                    }
                    // console.log(header, validData);
                    callback(header, validData);
                } catch (error) {
                    console.error('解析失败:', error);
                    layer.msg('XLS 文件解析失败，请检查文件是否损坏！', {icon: 2});
                }
            };

            // 读取文件为二进制数组（关键：必须使用 readAsArrayBuffer）
            reader.readAsArrayBuffer(file);
        },
        excelTimeToDateStrict: function (excelTime) {
            const baseDate = new Date(1899, 11, 30); // 1899-12-30（序列值 0）
            const millisecondsPerDay = 86400000;
        
            // 修正 1900 年问题：1900-03-01 对应的序列值是 60，实际应为 1900-02-28（序列值 59）
            const isAfter1900Leap = excelTime > 59; 
            const adjustDays = isAfter1900Leap ? 1 : 0;
        
            const date = new Date(baseDate.getTime() + (excelTime - adjustDays) * millisecondsPerDay);
            return date;
        },
        formatDateToYyyyMmDd: function (date) {
            const year = date.getFullYear();
            // 月份从 0 开始，需 +1 并补零
            const month = String(date.getMonth() + 1).padStart(2, '0');
            // 日期补零
            const day = String(date.getDate()).padStart(2, '0');
            return `${year}-${month}-${day}`;
        },
        // 展示处理后的数据
        renderLayuiTable: function(header, data) {
            // console.log(header)
            // console.log(data)
            // layui.table.destroy('currentTable');
            // 初始化 Layui 表格
            var cols = active.generateTableCols(header);
            var d = active.generateTableDatas(data);
            console.log(d);
            // console.log(cols);
            // return false;
            console.log(this.table)
            if (this.table == null) {
                this.table = layui.table.render({
                    elem: '#currentTable', // 绑定表格容器
                    page: true, // 开启分页
                    limit: 10, // 每页显示 10 条
                    limits: [10, 20, 30, 50], // 分页选项
                    cols: [cols], // 动态生成列配置（根据首行标题）
                    data: d, // 数据源（必须是对象数组）
                    parseData: function(res) { // 可选：预处理数据（如时间格式转换）
                        return res;
                    }
                });
            } else {
                console.log(d)
                layui.table.reload('currentTable', {
                    data: d,
                });
            }
        },
        // 转换表格配置
        generateTableCols: function(header) {
            return header.map((title, index) => {
                return {
                    field: `col${index}`, // 字段名（需与数据中的键匹配，若数据是数组需调整）
                    title: title, // 列标题
                    width: 150, // 列宽（可自适应或固定）
                    align: 'center', // 对齐方式
                    edit: true, // 开启编辑功能
                };
            });
        },
        // 转换表格数据
        generateTableDatas: function(data) {
            return data.map(row => {
                var item = [];
                $.each(row, (index, value) => {
                    item[`col${index}`] = value;
                });
                return { ...item };
            });
        },
    }

    return {

        index: function () {
            ea.table.render({
                init: init,
                toolbar: ['refresh',
                    [
                        {
                            text: '导入',
                            url: init.import_url,
                            method: 'open',
                            auth: 'add',
                            class: 'layui-btn layui-btn-normal layui-btn-sm',
                            icon: 'fa fa-plus ',
                            extend: 'data-width="90%" data-height="95%"',
                        },
                        {
                            text: '转移数据到保单',
                            url: init.transfer_url,
                            method: 'none',
                            auth: 'add',
                            class: 'layui-btn layui-btn-normal layui-btn-sm',
                            icon: 'fa fa-plus ',
                            extend: 'lay-active="transfer" data-url="'+init.transfer_url+'" data-width="90%" data-height="95%"',
                        },
                    ],
                    // 'delete', 
                    // 'export', 
                    // 'recycle'
                ],
                cols: [[
                    {type: "checkbox"},
                    {field: 'id', width: 80, title: 'ID', searchOp: '='},
                    {field: 'create_at', minWidth: 80, title: '出单日期', search: 'range',},
                    {field: 'start_at', minWidth: 80, title: '起保日期', search: false},
                    {field: 'end_at', minWidth: 80, title: '止保日期', search: false},
                    {field: 'carno', minWidth: 80, title: '车牌号', search: false},
                    {field: 'insurer', minWidth: 80, title: '投保人', search: false},
                    {field: 'cost_sy', minWidth: 80, title: '商业险金额', search: false},
                    {field: 'cost_jq', minWidth: 80, title: '交强险金额', search: false},
                    {field: 'cost_cc', minWidth: 80, title: '车船税金额', search: false},
                    {field: 'cost_jc', minWidth: 80, title: '驾乘险金额', search: false},
                    {field: 'status', title: '状态', width: 85, selectList: {1: '无重复', 0: '重复'}, search: false, templet: function(d){
                        return d.status == 1 ? "<span style='color: blue'>无重复</span>" : "<span style='color: red'>重复</span>";
                    }},
                    {
                        width: 250,
                        title: '操作',
                        templet: ea.table.tool,
                        operat: [
                            // [
                            // {
                            //     text: '编辑',
                            //     url: init.edit_url,
                            //     method: 'open',
                            //     auth: 'edit',
                            //     class: 'layui-btn layui-btn-xs layui-btn-success',
                            //     extend: 'data-width="90%" data-height="95%"',
                            // }],
                            'delete']
                    }
                ]],
            });
            layui.util.on('lay-active', {
                transfer: function (data) {
                    var title = $(this).attr('data-title'),
                        url = $(this).attr('data-url'),
                        tableId = $(this).attr('data-table'),
                        field = $(this).attr('data-field') || 'id';

                    title = title || '确定进行该操作？';

                    var postData = {};
                    tableId = tableId || init.table_render_id;
                    var checkStatus = layui.table.checkStatus(tableId),
                        data = checkStatus.data;
                    if (data.length <= 0) {
                        ea.msg.error('请勾选需要操作的数据');
                        return false;
                    }
                    var ids = [];
                    $.each(data, function (i, v) {
                        ids.push(v[field]);
                    });
                    postData[field] = ids;
                    url = ea.url(url);
                    console.log(url, postData)
                    ea.msg.confirm(title, function () {
                        ea.request.fetch(url, postData)
                            .then(function(res){
                                if (res.code == 1) {
                                    ea.msg.success(res.msg, function () {
                                        table.reload(tableId);
                                        $('[data-treetable-refresh]').trigger("click");
                                    });
                                } else {
                                    ea.msg.error(res.msg);
                                }
                            });
                    });
                    return false;
                }
            });
            ea.listen();
        },

        import: function () {
            layui.util.on('lay-active', {
                submit: function (data) {
                    console.log(data, active.table)
                    if (active.table != null) {
                        var data = active.table.config.data;
                        if (data.length == 0) {
                            layer.msg('请先导入数据', {icon: 2});
                            return false;
                        }
                        // 生产唯一key
                        var keys = [];
                        for (const row of data) {
                            var key = row['col1']+row['col4']+row['col5'];
                            if (keys.indexOf(key) != -1) {
                                row['status'] = 0;
                            } else {
                                row['status'] = 1;
                                keys.push(key)
                            }
                        }
                        // console.log(keys)
                        // console.log(data)
                        // return false;
                        ea.request.fetch(ea.url(init.import_url), data)
                            .then(function(res){
                                console.log(res)
                                if (res.code == 1) {
                                    layer.msg('导入成功', {icon: 1});
                                    layer.closeAll();
                                    ea.api.closeCurrentOpen({
                                        refreshTable: true
                                    });
                                }
                            });
                    }
                    
                },
                
            })
            active.load();
            ea.listen();
        }
    };
});